// Forestil dig en fetchData-funktion, der returnerer et Promise
function fetchUserData() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ name: 'Alice' });
    }, 2000);
  });
}

// En hypotetisk Suspense-aktiveret datahentnings-hook
function useUserData() {
  const data = fetch(url);
  if (data.status === 'pending') {
    throw new Promise(resolve => {
      // Dette er, hvad Suspense opfanger
      setTimeout(() => resolve(null), 2000); 
    });
  }
  return data.value;
}

function UserProfile() {
  const userData = useUserData(); // Dette kald kan suspendere
  return 
Velkommen, {userData.name}!
;
}

function App() {
  return (
    Indlæser bruger...

2. Automatisk Batching

Batching er processen med at gruppere flere state-opdateringer i en enkelt re-render. Traditionelt set batchede React kun opdateringer, der fandt sted inden for event-handlere. Opdateringer, der blev initieret uden for event-handlere (f.eks. inden i promises eller `setTimeout`), blev ikke batchet, hvilket førte til unødvendige re-renders.

Hvordan det virker med concurrency: Med Concurrent Mode batcher React automatisk alle state-opdateringer, uanset hvor de stammer fra. Dette betyder, at hvis du har flere state-opdateringer, der sker i hurtig rækkefølge (f.eks. fra flere asynkrone operationer, der afsluttes), vil React gruppere dem og udføre en enkelt re-render, hvilket forbedrer ydeevnen og reducerer overhead fra flere gengivelsescyklusser.

Eksempel: Antag, at du henter data fra to forskellige API'er. Når begge er færdige, opdaterer du to separate stykker state. I ældre React-versioner kunne dette udløse to re-renders. I Concurrent Mode bliver disse opdateringer batchet, hvilket resulterer i en enkelt, mere effektiv re-render.

3. Transitions

Transitions er et nyt koncept, der er introduceret for at skelne mellem hasteopdateringer og ikke-hasteopdateringer. Dette er en kernemekanisme for at muliggøre afbrydelig gengivelse.

Hasteopdateringer: Dette er opdateringer, der kræver øjeblikkelig feedback, såsom at skrive i et inputfelt, klikke på en knap eller manipulere UI-elementer direkte. De skal føles øjeblikkelige.

Transition-opdateringer: Dette er opdateringer, der kan tage længere tid og ikke kræver øjeblikkelig feedback. Eksempler inkluderer gengivelse af en ny side efter at have klikket på et link, filtrering af en stor liste eller opdatering af relaterede UI-elementer, der ikke reagerer direkte på et klik. Disse opdateringer kan afbrydes.

Hvordan det virker med concurrency: Ved hjælp af `startTransition` API'et kan du markere visse state-opdateringer som transitions. Reacts planlægger vil derefter behandle disse opdateringer med en lavere prioritet og kan afbryde dem, hvis en mere presserende opdatering opstår. Dette sikrer, at mens en ikke-hasteopdatering (som gengivelse af en stor liste) er i gang, prioriteres hasteopdateringer (som at skrive i et søgefelt), hvilket holder UI'en responsiv.

Globalt Eksempel: Overvej en rejsebookingshjemmeside. Når en bruger vælger en ny destination, kan det udløse en kaskade af opdateringer: hentning af flydata, opdatering af hoteltilgængelighed og gengivelse af et kort. Hvis brugeren øjeblikkeligt beslutter sig for at ændre rejsedatoerne, mens de indledende opdateringer stadig behandles, tillader `startTransition` API'et React at sætte fly/hotel-opdateringerne på pause, behandle den presserende datoændring og derefter potentielt genoptage eller genstarte fly/hotel-hentningen baseret på de nye datoer. Dette forhindrer UI'en i at fryse under den komplekse opdateringssekvens.

Kodeeksempel (Illustrativt):

import { useState, useTransition } from 'react';

function SearchResults() {
  const [isPending, startTransition] = useTransition();
  const [query, setQuery] = useState('');
  const [results, setResults] = useState([]);

  const handleQueryChange = (e) => {
    const newQuery = e.target.value;
    setQuery(newQuery);

    // Markér denne opdatering som en transition
    startTransition(() => {
      // Simuler hentning af resultater, dette kan afbrydes
      fetchResults(newQuery).then(res => setResults(res));
    });
  };

  return (
    

      
      {isPending && 
Indlæser resultater...
}
      

        {results.map(item => (
          
{item.name}
        ))}
      
    
  );
}

4. Biblioteker og Økosystemintegration

Fordelene ved Concurrent Mode er ikke begrænset til Reacts kernefunktioner. Hele økosystemet tilpasser sig. Biblioteker, der interagerer med React, såsom routing-løsninger eller state management-værktøjer, kan også udnytte concurrency til at give en mere jævn oplevelse.

Eksempel: Et routing-bibliotek kan bruge transitions til at navigere mellem sider. Hvis en bruger navigerer væk, før den aktuelle side er fuldt gengivet, kan routing-opdateringen problemfrit afbrydes eller annulleres, og den nye navigation kan få forrang. Dette sikrer, at brugeren altid ser den mest opdaterede visning, de havde til hensigt.

Sådan Aktiveres og Bruges Concurrency-Funktioner

Selvom Concurrent Mode er et fundamentalt skift, er aktivering af dens funktioner generelt ligetil og involverer ofte minimale kodeændringer, især for nye applikationer eller ved vedtagelse af funktioner som Suspense og Transitions.

1. React Version

Concurrency-funktioner er tilgængelige i React 18 og nyere. Sørg for, at du bruger en kompatibel version:

npm install react@latest react-dom@latest

2. Root API (`createRoot`)

Den primære måde at tilmelde sig concurrency-funktioner er ved at bruge det nye `createRoot` API, når du monterer din applikation:

// index.js eller main.jsx
import ReactDOM from 'react-dom/client';
import App from './App';

const container = document.getElementById('root');
const root = ReactDOM.createRoot(container);
root.render();

Brug af `createRoot` aktiverer automatisk alle concurrency-funktioner, herunder automatisk batching, transitions og Suspense.

Bemærk: Det ældre `ReactDOM.render` API understøtter ikke concurrency-funktioner. Migrering til `createRoot` er et vigtigt skridt for at låse op for concurrency.

3. Implementering af Suspense

Som vist tidligere implementeres Suspense ved at omgive komponenter, der udfører asynkrone operationer, med en <Suspense> grænse og levere en fallback prop.

Bedste Praksis:

• Indlejre <Suspense> grænser for at håndtere loading-tilstande granulært.
• Bruge brugerdefinerede hooks, der integreres med Suspense for renere datahentningslogik.
• Overveje at bruge biblioteker som Relay eller Apollo Client, som har førsteklasses support til Suspense.

4. Brug af Transitions (`startTransition`)

Identificer ikke-haste UI-opdateringer og omgiv dem med startTransition.

Hvornår skal det bruges:

• Opdatering af søgeresultater efter en bruger skriver.
• Navigering mellem ruter.
• Filtrering af store lister eller tabeller.
• Indlæsning af yderligere data, der ikke umiddelbart påvirker brugerinteraktion.

Eksempel: For kompleks filtrering af et stort datasæt vist i en tabel, ville du sætte filterforespørgsels-state og derefter kalde startTransition for den faktiske filtrering og re-rendering af tabelrækkerne. Dette sikrer, at hvis brugeren hurtigt ændrer filterkriterierne igen, kan den forrige filtreringsoperation sikkert afbrydes.

Fordele ved Afbrydelig Gengivelse for Globale Målgrupper

Fordelene ved afbrydelig gengivelse og Concurrent Mode forstærkes, når man overvejer en global brugerbase med forskellige netværksforhold og enhedskapaciteter.

• Forbedret Opfattet Performance: Selv på langsommere forbindelser eller mindre kraftfulde enheder forbliver UI'en responsiv. Brugere oplever en mere kvik applikation, fordi kritiske interaktioner aldrig blokeres i lang tid.
• Forbedret Tilgængelighed: Ved at prioritere brugerinteraktioner bliver applikationer mere tilgængelige for brugere, der er afhængige af hjælpeteknologier, eller som kan have kognitive funktionsnedsættelser, der drager fordel af en konsekvent responsiv grænseflade.
• Reduceret Frustration: Globale brugere, der ofte opererer på tværs af forskellige tidszoner og med varierende tekniske opsætninger, sætter pris på applikationer, der ikke fryser eller halter. En jævn UX fører til højere engagement og tilfredshed.
• Bedre Ressourcestyring: På mobile enheder eller ældre hardware, hvor CPU og hukommelse ofte er begrænsede, tillader afbrydelig gengivelse React at styre ressourcer effektivt og sætte ikke-essentielle opgaver på pause for at gøre plads til kritiske.
• Konsekvent Oplevelse på Tværs af Enheder: Uanset om en bruger er på en high-end desktop i Silicon Valley eller en budget-smartphone i Sydøstasien, kan applikationens kerneresponsivitet opretholdes, hvilket bygger bro over kløften i hardware- og netværkskapaciteter.

Overvej en sprogindlæringsapp, der bruges af studerende over hele verden. Hvis en studerende downloader en ny lektion (en potentielt lang opgave), mens en anden prøver at besvare et hurtigt ordforrådsspørgsmål, sikrer afbrydelig gengivelse, at ordforrådsspørgsmålet besvares øjeblikkeligt, selvom downloadet er i gang. Dette er afgørende for uddannelsesværktøjer, hvor øjeblikkelig feedback er vital for læring.

Potentielle Udfordringer og Overvejelser

Selvom Concurrent Mode tilbyder betydelige fordele, indebærer vedtagelsen også en læringskurve og nogle overvejelser:

• Debugging: Debugging af asynkrone og afbrydelige operationer kan være mere udfordrende end debugging af synkron kode. At forstå eksekveringsflowet, og hvornår opgaver kan blive sat på pause eller genoptaget, kræver omhyggelig opmærksomhed.
• Mentalt Modelskift: Udviklere skal justere deres tankegang fra en rent sekventiel eksekveringsmodel til en mere samtidig, hændelsesdrevet tilgang. At forstå implikationerne af startTransition og Suspense er nøglen.
• Eksterne Biblioteker: Ikke alle tredjepartsbiblioteker er opdateret til at være concurrency-bevidste. Brug af ældre biblioteker, der udfører blokerende operationer, kan stadig føre til UI-frys. Det er vigtigt at sikre, at dine afhængigheder er kompatible.
• State Management: Selvom Reacts indbyggede concurrency-funktioner er kraftfulde, kan komplekse state management-scenarier kræve omhyggelig overvejelse for at sikre, at alle opdateringer håndteres korrekt og effektivt inden for det samtidige paradigme.

Fremtiden for React Concurrency

Reacts rejse ind i concurrency er i gang. Teamet fortsætter med at forfine planlæggeren, introducere nye API'er og forbedre udvikleroplevelsen. Funktioner som Offscreen API (der tillader komponenter at blive gengivet uden at påvirke den brugeropfattede UI, nyttigt til pre-rendering eller baggrundsopgaver) udvider yderligere mulighederne for, hvad der kan opnås med samtidig gengivelse.

Efterhånden som nettet bliver mere og mere komplekst, og brugernes forventninger til ydeevne og responsivitet fortsætter med at stige, bliver samtidig gengivelse ikke bare en optimering, men en nødvendighed for at bygge moderne, engagerende applikationer, der henvender sig til et globalt publikum.

Konklusion

React Concurrent Mode og dets kernekoncept om afbrydelig gengivelse repræsenterer en betydelig udvikling i, hvordan vi bygger brugergrænseflader. Ved at gøre det muligt for React at pause, genoptage og prioritere gengivelsesopgaver, kan vi skabe applikationer, der ikke kun er performante, men også utroligt responsive og modstandsdygtige, selv under tung belastning eller i begrænsede miljøer.

For et globalt publikum betyder dette en mere retfærdig og fornøjelig brugeroplevelse. Uanset om dine brugere tilgår din applikation fra en højhastigheds fiberforbindelse i Europa eller et mobilnetværk i et udviklingsland, hjælper Concurrent Mode med at sikre, at din applikation føles hurtig og flydende.

At omfavne funktioner som Suspense og Transitions, og at migrere til det nye Root API, er afgørende skridt mod at frigøre det fulde potentiale i React. Ved at forstå og anvende disse koncepter kan du bygge den næste generation af webapplikationer, der virkelig glæder brugere over hele verden.

Vigtigste Punkter:

• Reacts Concurrent Mode muliggør afbrydelig gengivelse og bryder med synkron blokering.
• Funktioner som Suspense, automatisk batching og Transitions er bygget på dette samtidige fundament.
• Brug createRoot til at aktivere concurrency-funktioner.
• Identificer og marker ikke-hasteopdateringer med startTransition.
• Samtidig gengivelse forbedrer UX markant for globale brugere, især på tværs af forskellige netværksforhold og enheder.
• Hold dig opdateret med Reacts udviklende concurrency-funktioner for optimal ydeevne.

Begynd at udforske Concurrent Mode i dine projekter i dag og byg hurtigere, mere responsive og mere dejlige applikationer for alle.